package cn.kgc;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author wangyue
 * @version 1.0
 */
public class Demo4 {
    //创建有10个线程的线程池
    static ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args){
        m4();
    }

    private static void m4() {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(
                () -> {
                    return "任务1的返回值";
                },
                executorService
        ).thenApply(
                //任务2等待任务1完成以后在执行。任务2中有返回值,任务2可以获得任务1的返回值。
                //val是任务1中的返回值
                (val) -> {
                    System.out.println("任务2中获得任务1的返回值是:" + val);
                    return "任务2的返回值";
                }
        );

        try {
            String result=future.get();
            System.out.println("任务2的返回值是:"+result);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
        executorService.shutdown();
    }

    private static void m3() {
        //任务2等待任务1完成以后在执行。任务2中没有返回值,任务2也不能获得任务1的返回值。
        CompletableFuture.runAsync(
                //任务1要执行的内容
                ()->{
                    try {
                        System.out.println("任务1开始执行");
                        Thread.sleep(10000);
                        System.out.println("任务1执行结束");
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                },
                //任务1在executorService线程池中执行
                executorService
        ).thenRun(
                //任务2在任务1执行完成以后接着执行,任务2在任务1的线程中执行。
                ()->{
                    System.out.println("任务2要执行的内容");
                }
        );
        //关闭线程池
        executorService.shutdown();
    }

    private static void m2() {
        //创建有返回值的CompletableFuture对象
        CompletableFuture<String> future= CompletableFuture.supplyAsync(
                //要执行的任务
                ()->{
                    return Thread.currentThread().getName();
                },
                //任务对应的线程池
                executorService
        );
        //获得任务执行的结果
        try {
            String threadName = future.get();
            System.out.println("线程名称:"+threadName);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
        //关闭线程池
        executorService.shutdown();
    }

    private static void m1() {
        //创建CompletableFuture对象,指定执行的任务。要执行的任务在 executorService线程池中的线程中执行。
        //runAsync方法时没有返回值的
        CompletableFuture<Void>  future= CompletableFuture.runAsync(
                //要执行的任务
                ()->{
                    String name = Thread.currentThread().getName();
                    System.out.println("当前线程名称:"+name);
                },
                //任务在executorService线程池中的线程执行
                executorService
        );
        //关闭线程池
        executorService.shutdown();
    }
}
